package Nonogram;

/**
 * Messages
 * @author Rachel Wedewer, Mollie Burkle, Kriste nNielsen
 * Date Modified: 4/30/2014
 * 
 * This class consists mostly of methods that send String values to controller.updateExplanation(String). This class was created
 * to eliminate the number of lines of code in the solver class, and keep things better organize things.  These 'messages' are
 * sent to the GUI to be display and by doing so explain the move the solver made.
 *  
 */
public class Messages {

    Nonogram controller;

    public Messages(Nonogram controller) {
        this.controller = controller;
    }

    public void firstClueEdgeMessage(int row, int col) {
        controller.updateExplanation(markedCell(row, col, 1) + "   Edge Columns filling in on " + (col + 1) + ", " + (row + 1) + "\n");
    }
    
    public void singleClueOverlap(boolean thisRow, int row, int col, int size) {
    	String line;
    	if (thisRow) {
    		line = "row"; }
    	else {
    		line = "column"; }

    	controller.updateExplanation(markedCell(row, col, 1)+ " Since there are " + size + " cells and ONE clue in this "
                                + line +", this is one of " + col + " overlapping cells that must be marked BLACK.\n");
    }
    
    public void singleClueComplete(boolean thisRow, int row, int col, int completedClue) {
    	String line;
    	if (thisRow) {
    		line = "row;";}
    else {
    	line = "column";}
    	
    	controller.updateExplanation(markedCell(row, col, 0) + " All " + completedClue + " marked squares have been satisfied in this "
                                    + line +" and so this cell must be BLANK.\n");
    }
    
    public void sumClueBlockComplete(boolean thisRow, int row, int col, int pointer) {
    	String line;
    	if (thisRow) {
    		line = "row";
    	}
    	else {
    		line = "column";
    	}
    	
    	controller.updateExplanation(markedCell(row, col, 0) + " Clue " + (pointer+1) + " in this  " + line + " has been"
                         		 				+ " satisfied and therefore must be followed by a blank mark.\n");
    }
    
    public void sumEqualsLineLength(boolean thisRow, int row, int col, int pointer) {
    	String line;
    	if (thisRow) {
    		line = "row";
    	}
    	else {
    		line = "column";
    	}
    	
    	controller.updateExplanation(markedCell(row, col, 1) + " The clues in this " + line + ", plus a mandatory "
                         		 				+ "blank mark that must separate each clue from the other, all sum up to equal the length of the " + line +". "
                         		 						+ "This cell will be marked black because the " + (pointer+1) + " clue has not yet been satisfied on the"
                         		 								+ " puzzle grid.\n");
    }

	public void overlapInRemainingSpace(int row, int col, boolean isRow, int space) {
            if (isRow) {
                controller.updateExplanation(markedCell(row, col, 1) + " because there are only " + space + " remaining cells in this ROW" +
                        " this must be one of the overlapping cells\n");
            }
            else {
                controller.updateExplanation(markedCell(row, col, 1) + " because there are only " + space + " remaining cells in this COLUMN" + 
                        " this must be one of the overlapping cells\n");
            }
        }
	
	public void markBetweenAlreadyMarked(int row, int col, boolean isFilled, boolean isRow, boolean multipleBlanks) {
        if (isFilled) {
            if (isRow) {
                controller.updateExplanation(markedCell(row, col, 1) + " because space between previously marked cells"
                        + " is less than or equal to the only clue of ROW\n");
            } 
            else {
                controller.updateExplanation(markedCell(row, col, 1) + " because space between previously marked cells"
                        + " is less than or equal to the only clue of COLUMN\n");
            }
        } 
        else {
            if (multipleBlanks) {
                if (isRow) {
                    controller.updateExplanation(markedCell(row, col, 0) + " because there is no room for the first clue of ROW"
                            + " between the first and next cell marked blank\n");
                } else {
                    controller.updateExplanation(markedCell(row, col, 0) + " because there is no room for the first clue of COLUMN"
                            + " between the first and next cell marked blank\n");
                }
            } 
            else {
                if (isRow) {
                    controller.updateExplanation(markedCell(row, col, 0) + " because there is no room for the first clue of ROW"
                            + " before the first blank cell\n");
                }
                else {
                    controller.updateExplanation(markedCell(row, col, 0) + " because there is no room for the first clue of COLUMN"
                            + " before the first blank cell\n");
                }
            }
        }
    }

    public void wiggleRoom(int row, int col, int markFilledCell, boolean isRow) {
        if (isRow) {
            controller.updateExplanation(markedCell(row, col, 0) + " because filled in cells in ROW cannot go beyond COL: "
                    + (markFilledCell + 1) + "\n");
        } else {
            controller.updateExplanation(markedCell(row, col, 0) + " because filled in cells in COLUMN cannot go beyound ROW: "
                    + (markFilledCell + 1) + "\n");
        }
    }
    
    public void multiClueAllFilledIn(int row, int col, boolean isFilled, boolean isRow) {
        if (isFilled) {
            if (isRow) {
                controller.updateExplanation(markedCell(row, col, 1) + " because ROW has the necessary number of blank cells\n");
            }
            else {
                controller.updateExplanation(markedCell(row, col, 1) + " because COLUMN has the necessary number of blank cells\n");
            }
        }
        else {
            if (isRow) {
                controller.updateExplanation(markedCell(row, col, 0) + " because all clues are satisfied for this ROW\n");
            }
            else {
                controller.updateExplanation(markedCell(row, col, 0) + " because all clues are satisfied for this COLUMN\n");
            }
        }
    }
    
    public void multiClueRemainingLineLengthEqualsClueSum(int row, int col, int fillState, boolean isRow, int space) {
        if (isRow) {
            controller.updateExplanation(markedCell(row, col, fillState) + " because the sum of the ROW's clues equals " + space
                    + ", which is all that remains in this ROW. Therefore, the remaining space will be filled in as "
                    + "indicated by the clues\n");
        }
        else {
            controller.updateExplanation(markedCell(row, col, fillState) + " because the sum of the COLUMN's clues equals " + space
                    + ", which is all that remains in this COLUMN. Therefore, the remaining space will be filled in as "
                    + "indicated by the clues\n");
        }
    }
    
    public void multiClueFirstClueComplete(int row, int col, boolean isRow) {
        if (isRow) {
            controller.updateExplanation(markedCell(row, col, 0) + " because the first clue of ROW is satisfied\n");
        }
        else {
            controller.updateExplanation(markedCell(row, col, 0) + " because the first clue of COLUMN is satisfied\n");
        }
    }
    
    public void multiClueLastClueComplete(int row, int col, boolean isRow) {
     if (isRow) {
         controller.updateExplanation(markedCell(row, col, 0) + " because the last clue of ROW is satisfied\n");
     }
     else {
        controller.updateExplanation(markedCell(row, col, 0) + " because the last clue of COLUMN is satisfied\n");
     }
    }

	
////////////
//Edge Derived FILLED
////////////
	public void firstRowClueEdgeMessage(int row, int col, int pointerPush, int clueValue) {
		String ex = "";
		
		if (pointerPush == 0){
			ex = "Since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in ROW "+(row+1)+") from the start of the row, the remaining cells behind "
					+ "that found FILLED cell to cell "
					+ clueValue + " can be marked FILLED, because if a range of " +clueValue +" marked filled cells was aligned to the first cell in the row"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row";
		}
		else if (pointerPush ==1) {	
			ex = "Being that there is " + pointerPush + " cell marked BLANK at the start of the row it acts as a new 'edge' of the row " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in ROW "+(row+1)+") from the 'new edge' of the start of the row, the remaining cells behind "
					+ "that found FILLED cell to cell "	+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cell in the row"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row";
		}
		
		else {	
			ex = "Being that there are " + pointerPush + " cells marked BLANK at the start of the row it acts as a new 'edge' of the row " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in ROW "+(row+1)+") from the 'new edge' of the start of the row, the remaining cells behind that "
					+ "found FILLED cell to cell "+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cells in the row"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row.";
		}
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}	
	
	public void LastRowClueEdgeMessage(int row, int col, int pointerPush, int clueValue) {
		String ex = "";
		
		if (pointerPush == 0){
			ex = "Since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in ROW "+(row+1)+") from the end of the row, the remaining cells before "
					+ "that found FILLED cell to cell "
					+ clueValue + " can be marked FILLED, because if a range of " +clueValue +" marked filled cells was aligned to the last cell in the row"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row";
		}
		else if (pointerPush ==1) {	
			ex = "Being that there is " + pointerPush + " cell marked BLANK at the end of the row it acts as a new 'edge' of the row " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in ROW "+(row+1)+") from the 'new edge' of the end of the row, the remaining cells before "
					+ "that found FILLED cell to cell "	+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cell in the row"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row";
		}
		
		else {	
			ex = "Being that there are " + pointerPush + " cells marked BLANK at the end of the row it acts as a new 'edge' of the row " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in ROW "+(row+1)+") from the 'new edge' of the end of the row, the remaining cells before that "
					+ "found FILLED cell to cell "+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cells in the corowlumn"+ 
					" it would have to at least extend to cell "+ clueValue + " in that row.";
		}
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}	

	public void firstColClueEdgeMessage(int row, int col, int pointerPush, int clueValue) {
		String ex = "";
		
		if (pointerPush == 0){
			ex = "Since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in COL "+(col+1)+") from the top of the column, the remaining cells behind "
					+ "that found FILLED cell to cell "
					+ clueValue + " can be marked FILLED, because if a range of " +clueValue +" marked filled cells was aligned to the first cell in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column";
		}
		else if (pointerPush ==1) {	
			ex = "Being that there is " + pointerPush + " cell marked BLANK at the start of the column it acts as a new 'edge' of the column " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in COL "+(col+1)+") from the 'new edge' of the top of the column, the remaining cells behind "
					+ "that found FILLED cell to cell "	+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cell in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column";
		}
		
		else {	
			ex = "Being that there are " + pointerPush + " cells marked BLANK at the start of the column it acts as a new 'edge' of the column " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the FIRST CLUE in COL "+(col+1)+") from the 'new edge' of the top of the column, the remaining cells behind that "
					+ "found FILLED cell to cell "+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cells in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column.";
		}
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}	
	
	public void LastColClueEdgeMessage(int row, int col, int pointerPush, int clueValue) {
		String ex = "";
		
		if (pointerPush == 0){
			ex = "Since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in COL "+(col+1)+") from the end of the column, the remaining cells before "
					+ "that found FILLED cell to cell "
					+ clueValue + " can be marked FILLED, because if a range of " +clueValue +" marked filled cells was aligned to the last cell in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column";
		}
		else if (pointerPush ==1) {	
			ex = "Being that there is " + pointerPush + " cell marked BLANK at the end of the column it acts as a new 'edge' of the column " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in COL "+(col+1)+") from the 'new edge' of the bottom of the column, the remaining cells before "
					+ "that found FILLED cell to cell "	+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cell in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column";
		}
		
		else {	
			ex = "Being that there are " + pointerPush + " cells marked BLANK at the end of the column it acts as a new 'edge' of the column " 
					+ "and since a marked FILLED cell was found within "+ clueValue + 
					" cells (corresponding to the LAST CLUE in COL "+(col+1)+") from the 'new edge' of the bottom of the column, the remaining cells before that "
					+ "found FILLED cell to cell "+ clueValue + " can be marked FILLED, because if a range of " +clueValue 
					+" marked filled cells was aligned to the blank cells in the column"+ 
					" it would have to at least extend to cell "+ clueValue + " in that column.";
		}
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}	
////////////
//Edge Derived Blank
////////////	
	public void firstRowClueEdgeBlankMessage(int row, int col, int clueValue) {
		String ex = "";
		
		ex = "Since a marked BLANK cell was found within "+ clueValue + 
				" cells (corresponding to the FIRST CLUE in ROW "+(row+1)+") from the start of the row, the remaining cells behind "
				+ "that found BLANK cell to the start of the row "
				+  " can be marked BLANK, because the clue will not fit in the space from the start of the line"+ 
				" to the found BLANK cell of that row";

		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	public void LastRowClueEdgeBlankMessage(int row, int col, int clueValue) {
		String ex = "";
		
		ex = "Since a marked BLANK cell was found within "+ clueValue + 
				" cells (corresponding to the LAST CLUE in ROW "+(row+1)+") from the end of the row, the remaining cells after "
				+ "that found BLANK cell to the end of the row "
				+  " can be marked BLANK, because the clue will not fit in the space from the found BLANK cell to "
				+ "the end of the line of that row";

		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}	

	
	public void firstColClueEdgeBlankMessage(int row, int col, int clueValue) {
		String ex = "";
		
		ex = "Since a marked BLANK cell was found within "+ clueValue + 
				" cells (corresponding to the FIRST CLUE in COL "+(col+1)+") from the start of the column, the remaining cells behind "
				+ "that found BLANK cell to the start of the column "
				+  " can be marked BLANK, because the clue will not fit in the space from the start of the column"+ 
				" to the found BLANK cell of that column";

		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	public void LastColClueEdgeBlankMessage(int row, int col, int clueValue) {
		String ex = "";
		
		ex = "Since a marked BLANK cell was found within "+ clueValue + 
				" cells (corresponding to the LAST CLUE in COL "+(col+1)+") from the end of the column, the remaining cells after "
				+ "that found BLANK cell to the end of the column "
				+  " can be marked BLANK, because the clue will not fit in the space from the found BLANK cell to "
				+ "the end of the line of that column";

		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}	
/////////
//Overlap
////////
	public void overlapFirstRowClueMC(int row, int col){
		String ex = "";
		
		ex = "This cell was able to be marked FILLED because if the line was aligned to the start of the ROW and marking the clues spaces as tightly"
				+ " as possible with given cells between clues marked BLANK and the same principle was applied to the end of the row aligning the last clue to the "
				+ "edge and marking toward the start of the row, there exists a confirmed"
				+ " and forced overlap of the FIRST CLUE in the row.";
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}
	
	public void overlapLastRowClueMC(int row, int col){
		String ex = "";
		
		ex = "This cell was able to be marked FILLED because if the line was aligned to the end of the ROW and marking the clues spaces as tightly"
				+ " as possible with given cells between clues marked BLANK and the same principle was applied to the start of the row aligning the first clue to the "
				+ "edge and marking toward the end of the row, there exists a confirmed"
				+ " and forced overlap of the LAST CLUE in the row.";
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}
	
	public void overlapFirstColClueMC(int row, int col){
		String ex = "";
		
		ex = "This cell was able to be marked FILLED because if the line was aligned to the start of the COLUMN and marking the clues spaces as tightly"
				+ " as possible with given cells between clues marked BLANK and the same principle was applied to the end of the column aligning the last clue to the "
				+ "edge and marking toward the start of the column, there exists a confirmed"
				+ " and forced overlap of the FIRST CLUE in the column.";
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}
	
	public void overlapLastColClueMC(int row, int col){
		String ex = "";
		
		ex = "This cell was able to be marked FILLED because if the line was aligned to the end of the COLUMN and marking the clues spaces as tightly"
				+ " as possible with given cells between clues marked BLANK and the same principle was applied to the start of the column aligning the last clue to the "
				+ "edge and marking toward the start of the column, there exists a confirmed"
				+ " and forced overlap of the LAST CLUE in the column.";
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}

//////
// Small Gap
//////
	public void smallGapRow(int row, int col, int smallClue){
		String ex = "";
		
		ex = "This cell was able to be marked BLANK, because it was a part of a gap of unknown cells in the ROW "
				+ "with blank/edges surrounding it and this gap is smaller than the smallest clue, " + smallClue + ", in the ROW";
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	public void smallGapCol(int row, int col, int smallClue){
		String ex = "";
		
		ex = "This cell was able to be marked BLANK, because it was a part of a gap of unknown cells in the COL "
				+ "with blank/edges surrounding it and this gap is smaller than the smallest clue, " + smallClue + ", in the COL";
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}

//////
// Processing Line
//////
	public void processFromFrontRowBlank(int row, int col, int currentCluePosition, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked BLANK, because starting at the beginning of the line to this cell-1 in the ROW "
				+ "has been fully marked.  And continuing down the ROW after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the ROW,  determined by the " + (currentCluePosition) +" clue(s) previousy marked,"
				+ " the current clue has been found and will have to have a BLANK cell following it.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	public void processFromFrontRowFill(int row, int col, int currentCluePosition, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked FILLED, because starting at the beginning of the line to this cell-1 in the ROW "
				+ "has been fully marked.  And continuing down the ROW after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the ROW,  determined by the " + (currentCluePosition) +" clue(s) previousy marked,"
				+ " the current clue has to be completed and needs this cell marked FILLED.";
		
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}

	public void processFromBackRowBlank(int row, int col, int currentCluePosition, int numClues, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked BLANK, because starting at the end of the line to this cell-1 in the ROW "
				+ "has been fully marked.  And continuing toward the front of the ROW after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the ROW,  determined by the " + (numClues - currentCluePosition) +" clue(s) previousy marked (Looking at the last clue"
				+ " working toward the first) the current clue has been found and will have to have a BLANK cell before it.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	public void processFromBackRowFill(int row, int col, int currentCluePosition, int numClues, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked FILLED, because starting at the end of the line to this cell-1 in the ROW "
				+ "has been fully marked.  And continuing toward the front of the ROW after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the ROW,  determined by the " + (numClues - currentCluePosition) +" clue(s) previousy marked (Looking at the last clue"
				+ " working toward the first) the current clue has to be completed and needs this cell marked FILLED.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	public void processFromFrontColBlank(int row, int col, int currentCluePosition, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked BLANK, because starting at the beginning of the line to this cell-1 in the COL "
				+ "has been fully marked.  And continuing down the COL after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the COL,  determined by the " + (currentCluePosition) +" clue(s) previousy marked,"
				+ " the current clue has been found and will have to have a BLANK cell following it.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	public void processFromFrontColFill(int row, int col, int currentCluePosition, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked FILLED, because starting at the beginning of the line to this cell-1 in the COL "
				+ "has been fully marked.  And continuing down the COL after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the COL,  determined by the " + (currentCluePosition) +" clue(s) previousy marked,"
				+ " the current clue has to be completed and needs this cell marked FILLED.";
		
		
		controller.updateExplanation( markedCell(row, col,1) +"   "+ex + "\n");	
	}

	public void processFromBackColBlank(int row, int col, int currentCluePosition, int numClues, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked BLANK, because starting at the bottom of the line to this cell-1 in the COL "
				+ "has been fully marked.  And continuing toward the top of the COL after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the COL,  determined by the " + (numClues - currentCluePosition) +" clue(s) previousy marked (looking at the last clue"
				+ " working toward the first) the current clue has been found and will have to have a BLANK cell before it.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	public void processFromBackColFill(int row, int col, int currentCluePosition, int numClues, int currentClue){
		String ex = "";
		
		
		ex = "This cell was able to be marked FILLED, because starting at the bottom of the line to this cell-1 in the COL "
				+ "has been fully marked.  And continuing toward the top of the COL after passing a gap of FILLED cell(s) related to the current "
				+ "clue ("+ currentClue + ") in the COL,  determined by the " + (numClues - currentCluePosition) +" clue(s) previousy marked (Looking at the last clue"
				+ " working toward the first) the current clue has to be completed and needs this cell marked FILLED.";
		
		
		controller.updateExplanation( markedCell(row, col,0) +"   "+ex + "\n");	
	}
	
	
	public String markedCell(int row, int col, int marked)	{
		
		String mark;
		if (marked == 1){
			mark = "FILLED";
		}
		else if (marked == 0){
			mark = "BLANK";
		}
		else {
			mark = "you have issues";
		}
		return("[COL: "+(col+1)+", ROW: "+(row+1) +"] was marked "+ mark +"\n");
		
	}



	
}
